import 'dart:async';
import 'dart:math';

import 'package:battery_plus/battery_plus.dart';
import 'package:flutter/material.dart';
import 'package:sensors_plus/sensors_plus.dart'; // 添加 sensors_plus 导入
import 'package:geolocator/geolocator.dart'; // 添加 geolocator 导入
import 'package:permission_handler/permission_handler.dart'; // 添加 permission_handler 导入

class SensorDemo extends StatefulWidget {
  const SensorDemo({super.key});

  @override
  State<SensorDemo> createState() => _SensorDemoState();
}

class _SensorDemoState extends State<SensorDemo> {
  // 添加陀螺仪数据的变量
  String _gyroscopeData = '陀螺仪: 没有开始';
  StreamSubscription<GyroscopeEvent>? _gyroscopeSubscription;
  bool _isListening = false;
  String _batteryLevel = '电池 电量: 未知'; // 添加电池电量变量
  String _batteryStatus = '电池状态: 未知'; // 添加电池状态变量
  String _batterySaveMode = '省电模式: 未知'; // 添加省电模式变量
  String _position = '位置: 未知'; // 添加位置信息变量

  @override
  void initState() {
    super.initState();
    // 初始化陀螺仪监听器，但不立即启动
    _checkLocationService();
      final change = Battery().onBatteryStateChanged;
      // ignore: avoid_print, unnecessary_brace_in_string_interps
      print("change${change}");
  }

  // 新增方法：检查位置服务是否启用
  Future<void> _checkLocationService() async {
    bool isLocationServiceEnabled = await Geolocator.isLocationServiceEnabled();
    if (!isLocationServiceEnabled) {
      setState(() {
        _position = '位置服务未启用';
      });
    } else {
      setState(() {
        _position = '位置服务已启用';
      });
    }
  }

  /// 切换陀螺仪监听状态
  ///
  /// 当[_isListening]为true时，取消陀螺仪事件的监听，停止监听陀螺仪数据
  /// 否则，开始监听陀螺仪事件，并更新UI显示陀螺仪数据
  void _toggleGyroscopeListening() {
    if (_isListening) {
      // 取消现有的陀螺仪事件订阅，如果存在的话
      _gyroscopeSubscription?.cancel();
      setState(() {
        // 重置陀螺仪数据为未开始状态
        _gyroscopeData = '陀螺仪： 没有开始';
        // 更新监听状态为false，表示未在监听中
        _isListening = false;
      });
    } else {
      // 开始监听陀螺仪事件
      // ignore: deprecated_member_use
      _gyroscopeSubscription = gyroscopeEvents.listen(
        (GyroscopeEvent event) {
          setState(() {
            // 更新UI显示实时的陀螺仪数据，格式化为两位小数
            _gyroscopeData =
                '陀螺仪: (x${event.x.toStringAsFixed(2)}, y${event.y.toStringAsFixed(2)}, z${event.z.toStringAsFixed(2)})';
          });
        },
        onError: (error) {
          setState(() {
            // 在发生错误时更新UI显示错误信息
            _gyroscopeData = '陀螺仪： 发声错误: $error';
          });
        },
      );
      setState(() {
        // 更新监听状态为true，表示正在监听中
        _isListening = true;
      });
    }
  }

  /// 异步获取电池电量
  ///
  /// 此函数创建一个Battery实例并使用它来获取当前电池电量。
  /// 获取到的电量信息将以字符串形式在界面中显示。
  Future<void> _getBatteryLevel() async {
    final battery = Battery();
    final level = await battery.batteryLevel;
    setState(() {
      _batteryLevel = '电池电量: $level%';
    });
  }

  /// 异步获取电池状态
  ///
  /// 此函数创建一个Battery实例并使用它来获取当前电池状态。
  /// 获取到的状态信息将以字符串形式在界面中显示。
  Future<void> _getBatteryStatus() async {
    final battery = Battery();
    battery.onBatteryStateChanged.listen((BatteryState state) {
      setState(() {
        // "电池状态: BatteryState.full 是否省电中 false"
        if (state == BatteryState.full) {
          _batteryStatus = '电池以充满';
        } else if (state == BatteryState.charging) {
          _batteryStatus = '电池正在充电';
        } else if (state == BatteryState.discharging) {
          _batteryStatus = '电池正在放电';
        } else if (state == BatteryState.unknown) {
          _batteryStatus = '电池状态未知';
        }
      });
    });
  }

  /// 异步获取电池省电模式
  ///
  /// 此函数创建一个Battery实例并使用它来获取当前电池是否处于省电模式。
  /// 获取到的状态信息将以字符串形式在界面中显示。
  Future<void> _getBatterySaveMode() async {
    final battery = Battery();
    final isstate = await battery.isInBatterySaveMode;
    setState(() {
      _batterySaveMode = '省电模式: ${isstate ? '是' : '否'}';
      // ignore: avoid_print
      print(isstate);
    });
  }



  /// 异步获取当前位置
  ///
  /// 此函数尝试获取用户的当前地理位置。如果成功，将地理位置信息（纬度和经度）
  /// 以字符串形式在界面中显示。如果发生错误，将捕获异常并显示错误信息。
  Future<void> _getCurrentPosition() async {
    // 请求位置权限
    var status = await Permission.location.request();
    if (status.isGranted) {
      try {
        Position position = await Geolocator.getCurrentPosition(
          desiredAccuracy: LocationAccuracy.high,
        );
        setState(() {
          // 40.11131465435028,116.36271357536316
          // 39.947101659,116.404001365
          // 手机在室内转换后的坐标
          // 40.11891465755791,116.37543763756659
          // 40.11891465755791,116.37543763756659
          // 手机在外面获取到的精准坐标
          // 40.11142194271088,116.36125981807709
          // 40.11142194271088,116.36125981807709
          // 手机在外面获取到的精准坐标转换后的百度坐标
          // 40.118946147700086, 116.37394854564329
          // List<double> gcj = CoordinateConverter.wgs84ToGcj02(
          //     40.11142194271088, 116.36125981807709);


          // 获取纬度和经度 position.latitude, position.longitude
          // 转换为高德坐标
          List<double> gcj = CoordinateConverter.wgs84ToGcj02(
              position.latitude, position.longitude);
          
          // 转换为百度坐标
          List<double> wgs = CoordinateConverter.gcj02ToBd09(gcj[0], gcj[1]);
          _position = '位置 ${wgs[0]}, ${wgs[1]}';
          // ignore: avoid_print
          print(_position);
        });
      } catch (e) {
        setState(() {
          _position = '位置发生错误: $e';
        });
      }
    } else {
      setState(() {
        _position = '位置权限被拒绝';
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('SensorDemo'),
        elevation: 0,
      ),
      body: Container(
        padding: const EdgeInsets.all(6),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            // 显示陀螺仪数据
            Text(_gyroscopeData),
            const SizedBox(height: 20),
            // 添加获取陀螺仪数据按钮
            ElevatedButton(
              onPressed: _toggleGyroscopeListening,
              child: Text(_isListening ? '停止 陀螺仪' : '开始 陀螺仪'),
            ),

            const SizedBox(height: 20),
            // 显示电池电量
            Text(_batteryLevel),
            const SizedBox(height: 20),
            // 添加获取电池电量按钮
            ElevatedButton(
              onPressed: _getBatteryLevel,
              child: const Text('获取 电池 电量'),
            ),

            const SizedBox(height: 20),
            // 显示电池状态
            Text(_batteryStatus),
            const SizedBox(height: 20),
            // 添加获取电池状态按钮
            ElevatedButton(
              onPressed: _getBatteryStatus,
              child: const Text('获取 电池 状态'),
            ),

            const SizedBox(height: 20),
            // 显示电池省电模式
            Text(_batterySaveMode),
            const SizedBox(height: 20),
            // 添加获取电池省电模式按钮
            ElevatedButton(
              onPressed: _getBatterySaveMode,
              child: const Text('获取 电池 省电 模式'),
            ),

            const SizedBox(height: 20),
            // 显示位置信息
            Text(_position),
            const SizedBox(height: 20),
            // 添加获取位置信息按钮
            ElevatedButton(
              onPressed: _getCurrentPosition,
              child: const Text('获取 当前 位置'),
            ),

          ],
        ),
      ),
    );
  }
}
//   /**
//   * WGS-84转GCJ-02
//   * 将WGS-84坐标系下的经纬度转换为GCJ-02坐标系下的经纬度
//   * @param wgLon 纬度
//   * @param wgLat 经度
//   * @return
//   */
class CoordinateConverter {
  // 定义π的值
  static const double pi = 3.1415926535897932384626;
  // 定义地球长半轴长度
  static const double a = 6378245.0;
  // 定义地球扁率
  static const double ee = 0.00669342162296594323;

  /// WGS-84转GCJ-02核心算法
  /// 将WGS-84坐标系下的经纬度转换为GCJ-02坐标系下的经纬度
  /// [wgLat] WGS-84坐标系下的纬度
  /// [wgLon] WGS-84坐标系下的经度
  /// 返回GCJ-02坐标系下的纬度和经度
  static List<double> wgs84ToGcj02(double wgLat, double wgLon) {
    // 检查是否在中国境外，如果是则无需转换
    if (_outOfChina(wgLat, wgLon)) return [wgLat, wgLon];

    // 计算纬度和经度的偏差
    double dLat = _transformLat(wgLon - 105.0, wgLat - 35.0);
    double dLon = _transformLon(wgLon - 105.0, wgLat - 35.0);

    // 将纬度转换为弧度
    double radLat = wgLat / 180.0 * pi;
    // 计算地球椭球体上的点的偏移
    double magic = sin(radLat);
    magic = 1 - ee * magic * magic;
    double sqrtMagic = sqrt(magic);

    // 调整纬度和经度的偏差
    dLat = (dLat * 180.0) / ((a * (1 - ee)) / (magic * sqrtMagic) * pi);
    dLon = (dLon * 180.0) / (a / sqrtMagic * cos(radLat) * pi);

    // 返回转换后的坐标
    return [wgLat + dLat, wgLon + dLon];
  }

  /// 判断坐标是否在中国境外
  /// [lat] 纬度
  /// [lon] 经度
  /// 返回是否在中国境外
  static bool _outOfChina(double lat, double lon) {
    return !(lon >= 72.004 &&
        lon <= 137.8347 &&
        lat >= 0.8293 &&
        lat <= 55.8271);
  }

  /// 计算纬度的转换值
  /// [x] 经度减去105的值
  /// [y] 纬度减去35的值
  /// 返回纬度的转换值
  static double _transformLat(double x, double y) {
    double ret = -100.0 +
        2.0 * x +
        3.0 * y +
        0.2 * y * y +
        0.1 * x * y +
        0.2 * sqrt(x.abs());
    ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
    ret += (20.0 * sin(y * pi) + 40.0 * sin(y / 3.0 * pi)) * 2.0 / 3.0;
    ret += (160.0 * sin(y / 12.0 * pi) + 320 * sin(y * pi / 30.0)) * 2.0 / 3.0;
    return ret;
  }

  /// 计算经度的转换值
  /// [x] 经度减去105的值
  /// [y] 纬度减去35的值
  /// 返回经度的转换值
  static double _transformLon(double x, double y) {
    double ret =
        300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * sqrt(x.abs());
    ret += (20.0 * sin(6.0 * x * pi) + 20.0 * sin(2.0 * x * pi)) * 2.0 / 3.0;
    ret += (20.0 * sin(x * pi) + 40.0 * sin(x / 3.0 * pi)) * 2.0 / 3.0;
    ret +=
        (150.0 * sin(x / 12.0 * pi) + 300.0 * sin(x / 30.0 * pi)) * 2.0 / 3.0;
    return ret;
  }

  /// GCJ-02转BD-09核心算法
  /// 将GCJ-02坐标系下的经纬度转换为BD-09坐标系下的经纬度
  /// [gcjLat] GCJ-02坐标系下的纬度
  /// [gcjLon] GCJ-02坐标系下的经度
  /// 返回BD-09坐标系下的纬度和经度
  static List<double> gcj02ToBd09(double gcjLat, double gcjLon) {
    double x = gcjLon, y = gcjLat;
    double z = sqrt(x * x + y * y) + 0.00002 * sin(y * pi);
    double theta = atan2(y, x) + 0.000003 * cos(x * pi);
    double bdLon = z * cos(theta) + 0.0065;
    double bdLat = z * sin(theta) + 0.006;
    return [bdLat, bdLon];
  }
}
